home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / hard / drivr / BetaScan_1.12.lha / BetaScan / ScannerDev / MakeILBM.c < prev    next >
C/C++ Source or Header  |  1998-10-04  |  12KB  |  451 lines
  1. /************************************************************************/
  2. /*                                                                      */
  3. /* Write image as ilbm                                                  */
  4. /*                                                                      */
  5. /*                                                                      */
  6. /*                                                                      */
  7. /*                                                                      */
  8. /************************************************************************/
  9.  
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13.  
  14. #include <exec/types.h>
  15. #include <datatypes/pictureclass.h>
  16.  
  17. #include "MakeILBM.h"
  18. #include "packer.h"
  19.  
  20. #define ID_XBMI MAKE_ID('X','B','M','I')
  21. #define ILBM_BUFLEN 1500000
  22.  
  23. struct ImageBuf
  24. {
  25.   UBYTE* buf;
  26.   ULONG  actualLen;
  27.   FILE*  fh;
  28. };
  29.  
  30. struct ILBMFile
  31. {
  32.   char* fileName;
  33.   int   formLenOffset;
  34.   int   bodyLenOffset;
  35.   UBYTE flags;
  36.   
  37.   UBYTE depth;
  38.   UWORD width;
  39.   UWORD height;
  40.   UWORD xdpi;
  41.   UWORD ydpi;
  42.  
  43.   ULONG scanLineWidth;
  44.   ULONG bufLen;
  45.   struct ImageBuf buf[3];
  46. };
  47.  
  48. #define ILBMFLAGS_COMPRESS  (0x01 << 0)
  49. #define ILBMFLAGS_TEMPFILE  (0x01 << 1)
  50.  
  51. struct xbmi
  52. {
  53.   WORD xbmi_type;   /* ILBM_PAL, ILBM_RGB, ... (se below) */
  54.   WORD xbmi_xdpi;
  55.   WORD xbmi_ydpi;
  56. };
  57.  
  58.  
  59. #define ILBM_PAL        0       /* BODY data = indexes into the palette (CMAP)
  60.                                  * numcolors = 1<<depth;
  61.                                  */
  62.  
  63. #define ILBM_GREY       1       /* BODY =  grayscale values
  64.                                  * Bits per sample = number of bitplanes.
  65.                                  * Samples per pixel = 1.
  66.                                  * black = 0, white = (1<<depth)-1;
  67.                                  */
  68.  
  69. #define ILBM_RGB        2       /* BODY data = red, green, and blue values.
  70.                                  * Bits per sample = depth/3.
  71.                                  * Samples per pixel = 3.
  72.                                  */
  73.  
  74. #define ILBM_RGBA       3       /* BODY data = red, green, blue, and alpha
  75.                                  * channel values.
  76.                                  * Bits per sample = depth/4.
  77.                                  * Samples per pixel = 4.
  78.                                  */
  79.  
  80. #define ILBM_CMYK       4       /* BODY data = cyan, magenta, yellow, and black
  81.                                  * values.
  82.                                  * Bits per sample = depth/4.
  83.                                  * Samples per pixel = 4.
  84.                                  */
  85.  
  86. #define ILBM_CMYKA      5       /* BODY data = cyan, magenta, yellow, black,
  87.                                  * and alpha channel values.
  88.                                  * Bits per sample = depth/5.
  89.                                  * Samples per pixel = 5.
  90.                                  */
  91.  
  92. #define ILBM_BW         6       /* BODY data = black and white bits.
  93.                                  * Bits per sample = 1.
  94.                                  * Samples per pixel = 1.
  95.                                  * white = 0, black = 1.
  96.                                  */
  97.  
  98. static char* tempfile[3] = {"temp.red","temp.green","temp.blue"};
  99.  
  100. static void makePlane(UBYTE* source,UBYTE* dest,int bit,int length)
  101. {
  102.   int   bitNum,byteNum;
  103.   UBYTE b,sourceMask;
  104.  
  105.   sourceMask = 0x01 << bit;
  106.   
  107.   for( byteNum = 0 ; byteNum < length ; byteNum++ )
  108.   {
  109.     UBYTE destMask;
  110.     
  111.     destMask = 0x80;
  112.     b = 0;
  113.     for( bitNum = 0 ; bitNum < 8 ; bitNum++ )
  114.     {
  115.       if( (*source) & sourceMask )
  116.         b |= destMask;
  117.  
  118.       destMask >>= 1;
  119.       source++;
  120.     }
  121.     *(dest++) = b;
  122.   }
  123. } 
  124.  
  125. static void makeILBM(struct ILBMFile* ilbmfh)
  126. {
  127.   struct BitMapHeader BMHD;
  128.   struct xbmi         XBMI;
  129.   FILE*  fh;
  130.   int    c;
  131.   
  132.   if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  133.   {
  134.     for( c = 0 ; c < 3 ; c++ )
  135.     {
  136.       ilbmfh->buf[c].fh = fopen(tempfile[c],"r");
  137.       setvbuf(ilbmfh->buf[c].fh,ilbmfh->buf[c].buf,_IOFBF,ilbmfh->bufLen);
  138.     }
  139.   }
  140.   
  141.   BMHD.bmh_Width = ilbmfh->width;
  142.   BMHD.bmh_Height = ilbmfh->height;
  143.   BMHD.bmh_Left = 0;
  144.   BMHD.bmh_Top = 0;
  145.   BMHD.bmh_Depth = ilbmfh->depth;
  146.   BMHD.bmh_Masking = 0;
  147.   BMHD.bmh_Pad = 0;
  148.   BMHD.bmh_Transparent = 0;
  149.   BMHD.bmh_XAspect = 1;
  150.   BMHD.bmh_YAspect = 1;
  151.   BMHD.bmh_PageWidth = ilbmfh->width;
  152.   BMHD.bmh_PageHeight = ilbmfh->height;
  153.   
  154.   switch( ilbmfh->depth )
  155.   {
  156.     case 1:
  157.       XBMI.xbmi_type = ILBM_BW;
  158.       break;
  159.     case 8:
  160.       XBMI.xbmi_type = ILBM_GREY;
  161.       break;
  162.     case 24:
  163.       XBMI.xbmi_type = ILBM_RGB;
  164.       break;
  165.   }        
  166.   XBMI.xbmi_xdpi = ilbmfh->xdpi;
  167.   XBMI.xbmi_ydpi = ilbmfh->ydpi;
  168.  
  169.   if( fh = fopen(ilbmfh->fileName,"w") )
  170.   {
  171.     int scanLine,color,bitNum;
  172.     ULONG lineLen,bodyLen,formLen;
  173.     ULONG temp,psize;
  174.     UBYTE *line;
  175.     UBYTE *pline = NULL;
  176.     UBYTE *scanbuf = NULL;
  177.  
  178.     lineLen = ((ilbmfh->width+7)/8+1) & 0xFFFFFFFE;
  179.     line = malloc(lineLen);
  180.     if( (ilbmfh->flags & ILBMFLAGS_COMPRESS) && (pline = malloc(lineLen*2)) )
  181.       BMHD.bmh_Compression = 1;
  182.     else
  183.       BMHD.bmh_Compression = 0;
  184.       
  185.     temp = ID_FORM;
  186.     fwrite(&temp,4,1,fh);
  187.     ilbmfh->formLenOffset = ftell(fh);
  188.     temp = 0;
  189.     fwrite(&temp,4,1,fh);
  190.  
  191.     temp = ID_ILBM;
  192.     fwrite(&temp,4,1,fh);
  193.  
  194.     temp = ID_BMHD;
  195.     fwrite(&temp,4,1,fh);
  196.     temp = sizeof(struct BitMapHeader);
  197.     fwrite(&temp,4,1,fh);
  198.     fwrite(&BMHD,sizeof(struct BitMapHeader),1,fh);
  199.     
  200.     temp = ID_XBMI;
  201.     fwrite(&temp,4,1,fh);
  202.     temp = sizeof(struct xbmi);
  203.     
  204.     fwrite(&temp,4,1,fh);
  205.     fwrite(&XBMI,sizeof(struct xbmi),1,fh);
  206.  
  207.     if( ilbmfh->depth == 1 )
  208.     {
  209.       UBYTE b;
  210.       
  211.       temp = ID_CMAP;
  212.       fwrite(&temp,4,1,fh);
  213.       temp = 3*2;;
  214.       fwrite(&temp,4,1,fh);
  215.  
  216.       b = 0xFF;
  217.       fwrite(&b,1,1,fh);
  218.       fwrite(&b,1,1,fh);
  219.       fwrite(&b,1,1,fh);
  220.  
  221.       b = 0;
  222.       fwrite(&b,1,1,fh);
  223.       fwrite(&b,1,1,fh);
  224.       fwrite(&b,1,1,fh);
  225.     }
  226.     else if( ilbmfh->depth == 8 )
  227.     {
  228.       UBYTE b;
  229.       int   i;
  230.       
  231.       temp = ID_CMAP;
  232.       fwrite(&temp,4,1,fh);
  233.       temp = 3*256;;
  234.       fwrite(&temp,4,1,fh);
  235.       for( i = 0 ;  i < 256 ; i++ )
  236.       {
  237.         b = (UBYTE)i;
  238.         fwrite(&b,1,1,fh);
  239.         fwrite(&b,1,1,fh);
  240.         fwrite(&b,1,1,fh);
  241.       }
  242.     }
  243.     
  244.     temp = ID_BODY;
  245.     fwrite(&temp,4,1,fh);
  246.     ilbmfh->bodyLenOffset = ftell(fh);
  247.     temp = 0;
  248.     fwrite(&temp,4,1,fh);
  249.  
  250.     if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  251.       scanbuf = malloc(ilbmfh->scanLineWidth);
  252.     
  253.     switch( ilbmfh->depth )
  254.     {
  255.       case 1:
  256.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  257.         {
  258.           if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  259.             fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[0].fh);
  260.           else
  261.             scanbuf = ilbmfh->buf[0].buf + scanLine*ilbmfh->scanLineWidth;
  262.  
  263.           if( pline == NULL )
  264.             fwrite(scanbuf,lineLen,1,fh);
  265.           else
  266.           {
  267.             psize = PackRow(scanbuf,pline,lineLen);
  268.             fwrite(pline,psize,1,fh);
  269.           }
  270.         }
  271.         break;
  272.       case 8:
  273.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  274.         {
  275.           if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  276.             fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[0].fh);
  277.           else
  278.             scanbuf = ilbmfh->buf[0].buf + scanLine*ilbmfh->scanLineWidth;
  279.           for( bitNum = 0 ; bitNum < 8 ; bitNum++ )
  280.           {
  281.             makePlane(scanbuf,line,bitNum,lineLen);
  282.             if( pline == NULL )
  283.               fwrite(line,lineLen,1,fh);
  284.             else
  285.             {
  286.               psize = PackRow(line,pline,lineLen);
  287.               fwrite(pline,psize,1,fh);
  288.             }
  289.           }
  290.         }
  291.         break;
  292.       case 24:
  293.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  294.         {
  295.           for( color = 0 ; color < 3 ; color++ )
  296.           {
  297.             if( ilbmfh->buf[color].buf )
  298.             {
  299.               if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  300.                 fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[color].fh);
  301.               else
  302.                 scanbuf = ilbmfh->buf[color].buf + scanLine*ilbmfh->scanLineWid